# Import Library (Satu-satunya sel kode dalam template ini)
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import librosa
import soundfile as sf
from PIL import Image
import cv2
from IPython.display import Audio, HTML, display
import os

# Set matplotlib untuk menampilkan plot inline
%matplotlib inline

# Tampilkan versi library untuk dokumentasi
print("Library versions:")
print(f"NumPy: {np.__version__}")
print(f"Matplotlib: {matplotlib.__version__}")
print(f"Librosa: {librosa.__version__}")
print(f"OpenCV: {cv2.__version__}")

# Tambahkan import lain jika diperlukan saat mengerjakan tugas

Library versions:
NumPy: 2.2.6
Matplotlib: 3.10.6
Librosa: 0.11.0
OpenCV: 4.12.0

# Memuat Audio dengan Sistem Fallback
PATH_AUDIO = os.path.join(os.getcwd(), 'data', 'audio.wav')

# Variabel untuk menyimpan hasil
y = None
sr = None
source_info = ""

# Opsi 1: Coba muat file lokal
try:
    if os.path.exists(PATH_AUDIO):
        y, sr = librosa.load(PATH_AUDIO, sr=None)  # sr=None untuk mempertahankan sample rate asli
        source_info = f"✅ Berhasil memuat: {PATH_AUDIO}"
    else:
        raise FileNotFoundError("File tidak ditemukan")
except:
    print(f"⚠️ Tidak dapat memuat {PATH_AUDIO}")
    
    # Opsi 2: Gunakan contoh bawaan librosa
    try:
        y, sr = librosa.load(librosa.ex('trumpet'), sr=None)
        source_info = "✅ Menggunakan contoh audio bawaan librosa (trumpet)"
    except:
        print("⚠️ Contoh librosa tidak tersedia")

# Konversi ke mono jika stereo
if y.ndim > 1:
    y = np.mean(y, axis=0)  # Rata-rata semua kanal
    source_info += " - Dikonversi ke mono"

# Pastikan tipe data float32 untuk efisiensi
y = y.astype(np.float32)

print(source_info)
print(f"📊 Shape data: {y.shape}")
print(f"🎵 Sample rate: {sr} Hz")

✅ Berhasil memuat: f:\mulmed\data\audio.wav
📊 Shape data: (10138576,)
🎵 Sample rate: 48000 Hz

# Analisis Metadata Audio
print("📋 METADATA AUDIO")
print("=" * 40)
print(f"🔢 Jumlah sampel: {len(y):,}")
print(f"🎵 Sample rate: {sr:,} Hz")
print(f"⏱️ Durasi: {len(y)/sr:.2f} detik")
print(f"📻 Jumlah kanal: {'Mono (1 kanal)' if y.ndim == 1 else f'Multi-kanal ({y.ndim} kanal)'}")
print(f"📊 Tipe data: {y.dtype}")
print()
print("📈 STATISTIK AMPLITUDO")
print("=" * 40)
print(f"🔽 Nilai minimum: {np.min(y):.4f}")
print(f"🔼 Nilai maksimum: {np.max(y):.4f}")
print(f"📊 Nilai rata-rata: {np.mean(y):.4f}")
print(f"📏 Standar deviasi: {np.std(y):.4f}")

# Cek apakah audio terlalu keras (clipping)
if np.abs(y).max() >= 0.99:
    print("⚠️ PERINGATAN: Audio mungkin mengalami clipping (terlalu keras)")
else:
    print("✅ Audio dalam range amplitudo yang sehat")

📋 METADATA AUDIO
========================================
🔢 Jumlah sampel: 10,138,576
🎵 Sample rate: 48,000 Hz
⏱️ Durasi: 211.22 detik
📻 Jumlah kanal: Mono (1 kanal)
📊 Tipe data: float32

📈 STATISTIK AMPLITUDO
========================================
🔽 Nilai minimum: -1.0000
🔼 Nilai maksimum: 1.0000
📊 Nilai rata-rata: 0.0000
📏 Standar deviasi: 0.2324
⚠️ PERINGATAN: Audio mungkin mengalami clipping (terlalu keras)

# Plot Waveform dengan Detail Zoom
# Buat vektor waktu
t = np.linspace(0, len(y)/sr, len(y))

# Setup plot dengan 2 subplot
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 8))

# Plot 1: Waveform lengkap
ax1.plot(t, y, color='blue', linewidth=0.5)
ax1.set_title('🎵 Waveform Audio Lengkap "Dont Let Me Down" - The Beatles', fontsize=14, fontweight='bold')
ax1.set_xlabel('Waktu (detik)')
ax1.set_ylabel('Amplitudo')
ax1.grid(True, alpha=0.3)
ax1.set_ylim([-1.1, 1.1])

# Tambahkan informasi durasi
duration_text = f'Durasi total: {len(y)/sr:.2f} detik'
ax1.text(0.02, 0.95, duration_text, transform=ax1.transAxes, 
         bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue", alpha=0.7))

# Plot 2: Zoom detail 0-27 detik
zoom_duration = min(27, (len(y)/sr))
zoom_samples = int(zoom_duration * sr)
t_zoom = t[:zoom_samples]
y_zoom = y[:zoom_samples]

ax2.plot(t_zoom, y_zoom, color='red', linewidth=1.5, marker='o', markersize=2)
ax2.set_title(f'🔍 Detail Waveform (0 - {zoom_duration:.3f} detik - Bagian Chorus Awal)', fontsize=14, fontweight='bold')
ax2.set_xlabel('Waktu (detik)')
ax2.set_ylabel('Amplitudo')
ax2.grid(True, alpha=0.3)
ax2.set_ylim([-1.1, 1.1])

# Tambahkan informasi zoom
zoom_text = f'Menampilkan {zoom_samples} sampel pertama'
ax2.text(0.02, 0.95, zoom_text, transform=ax2.transAxes,
         bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral", alpha=0.7))

plt.tight_layout()
plt.show()

print(f"✅ Waveform berhasil ditampilkan!")
print(f"📊 Total sampel yang diplot: {len(y):,}")
print(f"🔍 Sampel zoom detail: {zoom_samples}")

C:\Users\ANSEN\AppData\Local\Temp\ipykernel_3808\3130596663.py:39: UserWarning: Glyph 127925 (\N{MUSICAL NOTE}) missing from font(s) DejaVu Sans.
  plt.tight_layout()
C:\Users\ANSEN\AppData\Local\Temp\ipykernel_3808\3130596663.py:39: UserWarning: Glyph 128269 (\N{LEFT-POINTING MAGNIFYING GLASS}) missing from font(s) DejaVu Sans.
  plt.tight_layout()
c:\Users\ANSEN\.conda\envs\multimedia\Lib\site-packages\IPython\core\pylabtools.py:170: UserWarning: Glyph 127925 (\N{MUSICAL NOTE}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)
c:\Users\ANSEN\.conda\envs\multimedia\Lib\site-packages\IPython\core\pylabtools.py:170: UserWarning: Glyph 128269 (\N{LEFT-POINTING MAGNIFYING GLASS}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)

✅ Waveform berhasil ditampilkan!
📊 Total sampel yang diplot: 10,138,576
🔍 Sampel zoom detail: 1296000

# Memutar Audio di Notebook
print("🔊 Audio Player - Pastikan volume tidak terlalu keras!")
print(f"🎵 Durasi: {len(y)/sr:.2f} detik")
print(f"📻 Sample rate: {sr} Hz")
print("▶️ Klik tombol play di bawah untuk mendengar audio:")

# Tampilkan audio player
Audio(y, rate=sr)

🔊 Audio Player - Pastikan volume tidak terlalu keras!
🎵 Durasi: 211.22 detik
📻 Sample rate: 48000 Hz
▶️ Klik tombol play di bawah untuk mendengar audio:

# Hitung dan Plot Spectrogram (STFT)

# Parameter STFT
n_fft = 1024          # Ukuran FFT window
hop_length = 256      # Langkah antar frame
window = 'hann'       # Jenis window function

# Hitung STFT
D = librosa.stft(y, n_fft=n_fft, hop_length=hop_length, window=window)
magnitude = np.abs(D)
magnitude_db = librosa.amplitude_to_db(magnitude, ref=np.max)

# Setup plot dengan 2 subplot
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Plot 1: Magnitude Spectrogram (Linear)
img1 = librosa.display.specshow(
    magnitude, sr=sr, hop_length=hop_length, x_axis='time', y_axis='hz', ax=axes[0]
)
axes[0].set_title('📊 Spectrogram - Magnitude Linear', fontsize=14, fontweight='bold')
axes[0].set_xlabel('Waktu (detik)')
axes[0].set_ylabel('Frekuensi (Hz)')
plt.colorbar(img1, ax=axes[0], format='%+2.0f')

# Plot 2: Magnitude Spectrogram (Log dB)
img2 = librosa.display.specshow(
    magnitude_db, sr=sr, hop_length=hop_length, x_axis='time', y_axis='hz', ax=axes[1]
)
axes[1].set_title('📊 Spectrogram - Magnitude (dB)', fontsize=14, fontweight='bold')
axes[1].set_xlabel('Waktu (detik)')
axes[1].set_ylabel('Frekuensi (Hz)')
plt.colorbar(img2, ax=axes[1], format='%+2.0f dB')

plt.tight_layout()
plt.show()

# Informasi STFT
print("📋 INFORMASI STFT")
print("=" * 40)
print(f"🔢 Ukuran FFT          : {n_fft}")
print(f"👣 Hop length          : {hop_length}")
print(f"🪟 Window function     : {window}")
print(f"📊 Shape magnitude     : {magnitude.shape}")
print(f"⏱️ Resolusi waktu      : {hop_length/sr*1000:.1f} ms per frame")
print(f"🎵 Resolusi frekuensi  : {sr/n_fft:.1f} Hz per bin")
print(f"📈 Range magnitude (dB): {magnitude_db.min():.1f} – {magnitude_db.max():.1f}")

C:\Users\ANSEN\AppData\Local\Temp\ipykernel_3808\3249426224.py:34: UserWarning: Glyph 128202 (\N{BAR CHART}) missing from font(s) DejaVu Sans.
  plt.tight_layout()
c:\Users\ANSEN\.conda\envs\multimedia\Lib\site-packages\IPython\core\pylabtools.py:170: UserWarning: Glyph 128202 (\N{BAR CHART}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)

📋 INFORMASI STFT
========================================
🔢 Ukuran FFT          : 1024
👣 Hop length          : 256
🪟 Window function     : hann
📊 Shape magnitude     : (513, 39604)
⏱️ Resolusi waktu      : 5.3 ms per frame
🎵 Resolusi frekuensi  : 46.9 Hz per bin
📈 Range magnitude (dB): -80.0 – 0.0

# Hitung Mel-Spectrogram dan MFCC
# Parameter untuk Mel-spectrogram
n_mels = 64  # Jumlah mel bins
fmax = sr // 2  # Frekuensi maksimum (Nyquist frequency)

# Hitung Mel-spectrogram
mel_spec = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=n_fft, 
                                         hop_length=hop_length, n_mels=n_mels, fmax=fmax)
mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)

# Hitung MFCC (13 koefisien)
n_mfcc = 13
mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc, n_fft=n_fft, 
                           hop_length=hop_length, n_mels=n_mels)

# Setup plot dengan 2 subplot
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10))

# Plot 1: Mel-Spectrogram
img1 = librosa.display.specshow(mel_spec_db, x_axis='time', y_axis='mel',
                               sr=sr, hop_length=hop_length, fmax=fmax, ax=ax1)
ax1.set_title('🎶 Mel-Spectrogram (dB)', fontsize=14, fontweight='bold')
ax1.set_xlabel('Waktu (detik)')
ax1.set_ylabel('Frekuensi Mel')
plt.colorbar(img1, ax=ax1, format='%+2.0f dB')

# Plot 2: MFCC (Heatmap)
img2 = librosa.display.specshow(mfcc, x_axis='time', ax=ax2)
ax2.set_title('🎯 MFCC (13 Koefisien)', fontsize=14, fontweight='bold')
ax2.set_xlabel('Waktu (detik)')
ax2.set_ylabel('Koefisien MFCC')
plt.colorbar(img2, ax=ax2)

plt.tight_layout()
plt.show()

# Informasi Mel & MFCC
print("📋 INFORMASI MEL-SPECTROGRAM & MFCC")
print("=" * 50)
print(f"🎶 Jumlah Mel bins: {n_mels}")
print(f"🎯 Jumlah MFCC: {n_mfcc}")
print(f"📊 Shape Mel-spectrogram: {mel_spec.shape}")
print(f"📊 Shape MFCC: {mfcc.shape}")
print(f"📈 Range Mel-spectrogram (dB): {mel_spec_db.min():.1f} - {mel_spec_db.max():.1f}")
print(f"📈 Range MFCC: {mfcc.min():.2f} - {mfcc.max():.2f}")
print()
print("✅ Semua fitur spektral berhasil dihitung!")
print("🎵 Mel-spectrogram: Representasi frekuensi sesuai persepsi manusia")
print("🎯 MFCC: Ringkasan spektral untuk machine learning")

C:\Users\ANSEN\AppData\Local\Temp\ipykernel_3808\4280952748.py:34: UserWarning: Glyph 127926 (\N{MULTIPLE MUSICAL NOTES}) missing from font(s) DejaVu Sans.
  plt.tight_layout()
C:\Users\ANSEN\AppData\Local\Temp\ipykernel_3808\4280952748.py:34: UserWarning: Glyph 127919 (\N{DIRECT HIT}) missing from font(s) DejaVu Sans.
  plt.tight_layout()
c:\Users\ANSEN\.conda\envs\multimedia\Lib\site-packages\IPython\core\pylabtools.py:170: UserWarning: Glyph 127926 (\N{MULTIPLE MUSICAL NOTES}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)
c:\Users\ANSEN\.conda\envs\multimedia\Lib\site-packages\IPython\core\pylabtools.py:170: UserWarning: Glyph 127919 (\N{DIRECT HIT}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)

📋 INFORMASI MEL-SPECTROGRAM & MFCC
==================================================
🎶 Jumlah Mel bins: 64
🎯 Jumlah MFCC: 13
📊 Shape Mel-spectrogram: (64, 39604)
📊 Shape MFCC: (13, 39604)
📈 Range Mel-spectrogram (dB): -80.0 - 0.0
📈 Range MFCC: -422.66 - 184.04

✅ Semua fitur spektral berhasil dihitung!
🎵 Mel-spectrogram: Representasi frekuensi sesuai persepsi manusia
🎯 MFCC: Ringkasan spektral untuk machine learning

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from PIL import Image
import cv2
import numpy as np
import os

# Tampilkan versi pustaka untuk memastikan kompatibilitas
print("Versi pustaka yang digunakan:")
print(f"Matplotlib: {plt.matplotlib.__version__}")
print(f"PIL (Pillow): {Image.__version__}")
print(f"OpenCV: {cv2.__version__}")
print(f"NumPy: {np.__version__}")
print("✅ Semua pustaka berhasil dimuat!")
print("")
# Load Gambar dengan Sistem Fallback
PATH_IMAGE = os.path.join(os.getcwd(), 'data', 'gambar.jpeg')  # Ganti dengan path gambar Anda

# Variabel untuk menyimpan hasil
img_pil = None
source_info = ""

# Opsi 1: Coba muat file lokal dengan PIL
try:
    if os.path.exists(PATH_IMAGE):
        img_pil = Image.open(PATH_IMAGE)
        # Pastikan dalam mode RGB (bukan RGBA atau mode lain)
        if img_pil.mode != 'RGB':
            img_pil = img_pil.convert('RGB')
        source_info = f"✅ Berhasil memuat: {PATH_IMAGE}"
    else:
        raise FileNotFoundError("File tidak ditemukan")
except Exception as e:
    print(f"⚠️ Tidak dapat memuat {PATH_IMAGE}: {e}")
    
    # Opsi 2: Gunakan gambar contoh dari matplotlib
    try:
        # Membuat gambar contoh sederhana (gradient warna)
        height, width = 200, 300
        img_array = np.zeros((height, width, 3), dtype=np.uint8)
        
        # Buat gradient horizontal RGB
        for i in range(width):
            img_array[:, i, 0] = int(255 * i / width)      # Red channel
            img_array[:, i, 1] = int(255 * (1 - i / width)) # Green channel
            img_array[:, i, 2] = 128                        # Blue channel (konstan)
        
        img_pil = Image.fromarray(img_array)
        source_info = "✅ Menggunakan gambar contoh buatan (gradient RGB)"
        
    except Exception as e:
        print(f"❌ Error membuat gambar contoh: {e}")
        # Buat gambar solid sederhana sebagai fallback terakhir
        img_array = np.full((100, 100, 3), [255, 128, 0], dtype=np.uint8)  # Orange
        img_pil = Image.fromarray(img_array)
        source_info = "✅ Menggunakan gambar fallback (solid orange)"

print(source_info)
print(f"📊 Ukuran gambar: {img_pil.size} (lebar x tinggi)")
print(f"🎨 Mode warna: {img_pil.mode}")
print(f"📁 Format: {img_pil.format if img_pil.format else 'Generated'}")

Versi pustaka yang digunakan:
Matplotlib: 3.10.6
PIL (Pillow): 11.3.0
OpenCV: 4.12.0
NumPy: 2.2.6
✅ Semua pustaka berhasil dimuat!

✅ Berhasil memuat: f:\mulmed\data\gambar.jpeg
📊 Ukuran gambar: (1600, 1000) (lebar x tinggi)
🎨 Mode warna: RGB
📁 Format: JPEG

# Visualisasi Gambar dengan Matplotlib
plt.figure(figsize=(10, 6))

# Tampilkan gambar
plt.imshow(img_pil)
plt.title('Gambar Pemandangan Pohon dan Rawa Musim Gugur', fontsize=16, fontweight='bold', pad=20)

# Hilangkan axis untuk tampilan yang lebih bersih
plt.axis('off')

# Tambahkan informasi gambar sebagai text
info_text = f"Ukuran: {img_pil.size[0]} x {img_pil.size[1]} pixels\nMode: {img_pil.mode}"
plt.figtext(0.02, 0.02, info_text, fontsize=10, 
           bbox=dict(boxstyle="round,pad=0.5", facecolor="lightblue", alpha=0.8))

# Tampilkan dengan layout yang rapi
plt.tight_layout()
plt.show()

print("✅ Gambar berhasil ditampilkan!")
print(f"📐 Resolusi: {img_pil.size[0]} x {img_pil.size[1]} pixels")
print(f"🎨 Total pixel: {img_pil.size[0] * img_pil.size[1]:,}")

✅ Gambar berhasil ditampilkan!
📐 Resolusi: 1600 x 1000 pixels
🎨 Total pixel: 1,600,000

# Metadata Gambar - Informasi Lengkap
print("📋 METADATA GAMBAR")
print("=" * 50)

# Informasi dari PIL Image
print("🖼️ INFORMASI PIL IMAGE:")
print(f"📐 Ukuran (W x H): {img_pil.size[0]} x {img_pil.size[1]} pixels")
print(f"🎨 Mode warna: {img_pil.mode}")
print(f"📁 Format file: {img_pil.format if img_pil.format else 'Generated/Unknown'}")

# Konversi ke numpy array untuk analisis lebih detail
img_array = np.array(img_pil)

print("\n🔢 INFORMASI NUMPY ARRAY:")
print(f"📊 Shape (H, W, C): {img_array.shape}")
print(f"💾 Tipe data: {img_array.dtype}")
print(f"🗃️ Ukuran memori: {img_array.nbytes:,} bytes ({img_array.nbytes/1024:.1f} KB)")

# Statistik nilai pixel
print("\n📈 STATISTIK PIXEL:")
print(f"🔽 Nilai minimum: {np.min(img_array)}")
print(f"🔼 Nilai maksimum: {np.max(img_array)}")
print(f"📊 Nilai rata-rata: {np.mean(img_array):.1f}")
print(f"📏 Standar deviasi: {np.std(img_array):.1f}")

# Informasi channel
if len(img_array.shape) == 3:
    height, width, channels = img_array.shape
    print(f"\n🌈 INFORMASI CHANNEL:")
    print(f"📏 Dimensi: {height} (tinggi) x {width} (lebar) x {channels} (channel)")
    if channels == 3:
        print("🎨 Channel: Red, Green, Blue (RGB)")
        # Statistik per channel
        for i, color in enumerate(['Red', 'Green', 'Blue']):
            channel_mean = np.mean(img_array[:, :, i])
            print(f"   {color}: rata-rata = {channel_mean:.1f}")
    elif channels == 1:
        print("⚫ Channel: Grayscale")
else:
    print(f"\n⚫ GRAYSCALE IMAGE:")
    print(f"📏 Dimensi: {img_array.shape[0]} x {img_array.shape[1]}")

print(f"\n✅ Total informasi berhasil diekstrak!")
print(f"💡 Aspect ratio: {img_pil.size[0]/img_pil.size[1]:.2f} (W/H)")

📋 METADATA GAMBAR
==================================================
🖼️ INFORMASI PIL IMAGE:
📐 Ukuran (W x H): 1600 x 1000 pixels
🎨 Mode warna: RGB
📁 Format file: JPEG

🔢 INFORMASI NUMPY ARRAY:
📊 Shape (H, W, C): (1000, 1600, 3)
💾 Tipe data: uint8
🗃️ Ukuran memori: 4,800,000 bytes (4687.5 KB)

📈 STATISTIK PIXEL:
🔽 Nilai minimum: 0
🔼 Nilai maksimum: 255
📊 Nilai rata-rata: 93.1
📏 Standar deviasi: 75.9

🌈 INFORMASI CHANNEL:
📏 Dimensi: 1000 (tinggi) x 1600 (lebar) x 3 (channel)
🎨 Channel: Red, Green, Blue (RGB)
   Red: rata-rata = 111.9
   Green: rata-rata = 82.6
   Blue: rata-rata = 84.8

✅ Total informasi berhasil diekstrak!
💡 Aspect ratio: 1.60 (W/H)

# ============================================
# B4. TODO: Histogram Warna
# ============================================
print("\n### B4. Histogram Warna")

# Pastikan gambar dalam format numpy array (RGB)
if len(img_array.shape) == 3 and img_array.shape[2] == 3:
    colors = ('Red', 'Green', 'Blue')
    plt.figure(figsize=(10, 6))
    
    # Plot histogram untuk masing-masing channel
    for i, color in enumerate(colors):
        channel_data = img_array[:, :, i].ravel()  # Flatten array
        plt.hist(channel_data, bins=256, range=(0, 255), 
                 color=color.lower(), alpha=0.6, label=color)
    
    # Label dan judul
    plt.title("Histogram Distribusi Intensitas Warna (RGB)", fontsize=14, fontweight="bold")
    plt.xlabel("Intensitas Pixel (0-255)")
    plt.ylabel("Frekuensi")
    plt.legend()
    plt.grid(alpha=0.3, linestyle="--")
    plt.tight_layout()
    plt.show()
    
    print("✅ Histogram warna berhasil ditampilkan.")
    
    # --- Analisis sederhana ---
    mean_values = [np.mean(img_array[:, :, i]) for i in range(3)]
    dominant_channel = colors[np.argmax(mean_values)]
    print("\n📊 Analisis Histogram:")
    print(f"- Rata-rata intensitas: R={mean_values[0]:.1f}, G={mean_values[1]:.1f}, B={mean_values[2]:.1f}")
    print(f"- Channel dominan: {dominant_channel}")
    print("- Kontras dapat dilihat dari lebar sebaran histogram (std dev per channel).")
    for i, color in enumerate(colors):
        print(f"  {color}: std dev = {np.std(img_array[:, :, i]):.1f}")
    print("- Jika histogram menyebar luas → kontras tinggi; jika terkumpul sempit → kontras rendah.")
    
else:
    print("⚠️ Histogram hanya tersedia untuk gambar RGB (3 channel).")

### B4. Histogram Warna

✅ Histogram warna berhasil ditampilkan.

📊 Analisis Histogram:
- Rata-rata intensitas: R=111.9, G=82.6, B=84.8
- Channel dominan: Red
- Kontras dapat dilihat dari lebar sebaran histogram (std dev per channel).
  Red: std dev = 84.1
  Green: std dev = 70.4
  Blue: std dev = 68.8
- Jika histogram menyebar luas → kontras tinggi; jika terkumpul sempit → kontras rendah.

# Setup & Instalasi untuk Video Processing
# OpenCV dan matplotlib sudah diinstall sebelumnya, tapi pastikan tersedia
# !pip install -q opencv-python matplotlib numpy

# Import library yang dibutuhkan untuk video processing
# (beberapa sudah diimport sebelumnya untuk image processing)
print("📹 Setup Video Processing")
print("=" * 40)

# Pastikan semua library sudah tersedia
try:
    import cv2
    import matplotlib.pyplot as plt
    import numpy as np
    import os
    print("✅ OpenCV tersedia")
    print("✅ Matplotlib tersedia") 
    print("✅ NumPy tersedia")
except ImportError as e:
    print(f"❌ Error import: {e}")
    print("Jalankan: !pip install opencv-python matplotlib numpy")

# Tampilkan versi pustaka untuk video processing
print("\n📋 Versi pustaka untuk video:")
print(f"OpenCV: {cv2.__version__}")
print(f"Matplotlib: {plt.matplotlib.__version__}")
print(f"NumPy: {np.__version__}")
print("\n✅ Setup video processing selesai!")

📹 Setup Video Processing
========================================
✅ OpenCV tersedia
✅ Matplotlib tersedia
✅ NumPy tersedia

📋 Versi pustaka untuk video:
OpenCV: 4.12.0
Matplotlib: 3.10.6
NumPy: 2.2.6

✅ Setup video processing selesai!

# Load Video dengan Error Handling
PATH_VIDEO = os.path.join(os.getcwd(), 'data', 'video.mp4')  # Ganti dengan path video Anda

print("📹 Mencoba membaca video...")
print(f"🎯 Target file: {PATH_VIDEO}")

# Buat objek VideoCapture
cap = cv2.VideoCapture(PATH_VIDEO)

# Periksa apakah video berhasil dibuka
if cap.isOpened():
    print("✅ Video berhasil dibuka!")
    source_info = f"✅ Berhasil memuat: {PATH_VIDEO}"
    video_loaded = True
else:
    print(f"❌ Gagal membuka video: {PATH_VIDEO}")
    
    # Cek apakah file ada
    if not os.path.exists(PATH_VIDEO):
        print(f"📁 File tidak ditemukan: {PATH_VIDEO}")
        print("\n💡 Tips:")
        print("1. Pastikan file video ada di folder 'data/'")
        print("2. Coba format MP4, AVI, atau MOV")
        print("3. Periksa nama file dan ekstensi")
    else:
        print(f"📁 File ditemukan tapi tidak bisa dibaca")
        print("💡 Kemungkinan format tidak didukung atau file rusak")
    
    source_info = f"❌ Gagal memuat: {PATH_VIDEO}"
    video_loaded = False
    
    # Bersihkan resource
    cap.release()

print(f"\n📊 Status: {source_info}")
print(f"🎬 Video loaded: {video_loaded}")

if not video_loaded:
    print("\n⚠️ PERHATIAN:")
    print("Video tidak dapat dimuat. Bagian selanjutnya akan menampilkan error.")
    print("Silakan ganti PATH_VIDEO dengan file video yang valid.")


# Metadata Video - Ekstraksi Informasi Lengkap
if video_loaded:
    print("📋 METADATA VIDEO")
    print("=" * 50)
    
    # Ambil informasi dasar dari video
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    
    # Hitung durasi (detik)
    duration = frame_count / fps if fps > 0 else 0
    
    print("📐 RESOLUSI & DIMENSI:")
    print(f"🖼️ Lebar: {width} pixels")
    print(f"🖼️ Tinggi: {height} pixels")
    print(f"📊 Resolusi: {width} × {height}")
    print(f"💡 Aspect ratio: {width/height:.2f}")
    
    # Klasifikasi resolusi
    if height >= 2160:
        res_class = "4K Ultra HD"
    elif height >= 1080:
        res_class = "Full HD (1080p)"
    elif height >= 720:
        res_class = "HD (720p)"
    else:
        res_class = "Standard Definition"
    print(f"🏷️ Klasifikasi: {res_class}")
    
    print("\n⏱️ INFORMASI TEMPORAL:")
    print(f"🎬 Frame rate: {fps:.2f} fps")
    print(f"🔢 Total frame: {frame_count:,}")
    print(f"⏰ Durasi: {duration:.2f} detik ({duration/60:.1f} menit)")
    
    # Klasifikasi frame rate
    if fps >= 60:
        fps_class = "High frame rate (smooth motion)"
    elif fps >= 30:
        fps_class = "Standard frame rate"
    elif fps >= 24:
        fps_class = "Cinema frame rate"
    else:
        fps_class = "Low frame rate"
    print(f"🏷️ Klasifikasi FPS: {fps_class}")
    
    print("\n💾 ESTIMASI DATA:")
    # Estimasi ukuran data (asumsi 3 bytes per pixel untuk RGB)
    bytes_per_frame = width * height * 3
    total_bytes = bytes_per_frame * frame_count
    print(f"📊 Bytes per frame: {bytes_per_frame:,} ({bytes_per_frame/1024/1024:.1f} MB)")
    print(f"📦 Total estimasi (RGB): {total_bytes:,} bytes ({total_bytes/1024/1024/1024:.1f} GB)")
    
    print(f"\n✅ Metadata berhasil diekstrak!")
    
    # Simpan informasi untuk digunakan nanti
    video_info = {
        'width': width,
        'height': height, 
        'fps': fps,
        'frame_count': frame_count,
        'duration': duration
    }
    
else:
    print("❌ Video tidak dimuat - tidak dapat mengekstrak metadata")
    print("Pastikan PATH_VIDEO menuju ke file video yang valid")

📹 Mencoba membaca video...
🎯 Target file: f:\mulmed\data\video.mp4
✅ Video berhasil dibuka!

📊 Status: ✅ Berhasil memuat: f:\mulmed\data\video.mp4
🎬 Video loaded: True
📋 METADATA VIDEO
==================================================
📐 RESOLUSI & DIMENSI:
🖼️ Lebar: 640 pixels
🖼️ Tinggi: 360 pixels
📊 Resolusi: 640 × 360
💡 Aspect ratio: 1.78
🏷️ Klasifikasi: Standard Definition

⏱️ INFORMASI TEMPORAL:
🎬 Frame rate: 30.00 fps
🔢 Total frame: 593
⏰ Durasi: 19.77 detik (0.3 menit)
🏷️ Klasifikasi FPS: Standard frame rate

💾 ESTIMASI DATA:
📊 Bytes per frame: 691,200 (0.7 MB)
📦 Total estimasi (RGB): 409,881,600 bytes (0.4 GB)

✅ Metadata berhasil diekstrak!

# Visualisasi Frame BGR & RGB dari Video
if video_loaded:
    print("📹 Mengekstrak dan menampilkan frame...")

    # Tentukan frame yang akan diekstrak
    frame_first = 0
    frame_middle = frame_count // 2
    frame_last = max(0, frame_count - 1)

    frames_to_extract = [
        (frame_first, "Frame Awal"),
        (frame_middle, "Frame Tengah"),
        (frame_last, "Frame Akhir")
    ]

    # Setup plot dengan 2 baris: BGR (atas) dan RGB (bawah)
    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
    extracted_frames_bgr = []
    extracted_frames_rgb = []

    for i, (frame_idx, title) in enumerate(frames_to_extract):
        # Set posisi frame
        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)

        # Baca frame
        ret, frame = cap.read()

        if ret:
            # Simpan frame BGR
            extracted_frames_bgr.append(frame)

            # Konversi ke RGB
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            extracted_frames_rgb.append(frame_rgb)

            # Tampilkan frame BGR (atas)
            axes[0, i].imshow(frame)
            axes[0, i].set_title(f'{title} - BGR\n(Frame #{frame_idx})', fontsize=12, fontweight='bold')
            axes[0, i].axis('off')

            # Tampilkan frame RGB (bawah)
            axes[1, i].imshow(frame_rgb)
            axes[1, i].set_title(f'{title} - RGB\n(Frame #{frame_idx})', fontsize=12, fontweight='bold')
            axes[1, i].axis('off')

            # Tambahkan informasi timestamp di bawah RGB
            timestamp = frame_idx / fps
            axes[1, i].text(0.02, 0.98, f'Waktu: {timestamp:.2f}s',
                            transform=axes[1, i].transAxes, fontsize=10,
                            bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow", alpha=0.8),
                            verticalalignment='top')

        else:
            # Jika gagal membaca frame
            for row in range(2):
                axes[row, i].text(0.5, 0.5, f'❌ Gagal\nmembaca\n{title}',
                                  transform=axes[row, i].transAxes, fontsize=12,
                                  horizontalalignment='center', verticalalignment='center')
                axes[row, i].set_title(f'{title} (Error)', fontsize=12)
                axes[row, i].axis('off')

    plt.tight_layout()
    plt.show()

    # Informasi ekstraksi
    print(f"✅ Frame berhasil diekstrak!")
    print(f"📊 Resolusi frame: {width} × {height}")
    print(f"🎯 Frame yang diekstrak:")
    for frame_idx, title in frames_to_extract:
        timestamp = frame_idx / fps
        print(f"   {title}: Frame #{frame_idx} (waktu {timestamp:.2f}s)")

    print(f"\n💡 Total frame berhasil diekstrak: {len(extracted_frames_bgr)}")

    # Bersihkan resource video capture
    cap.release()
    print("🔄 Video capture resource dibersihkan")

else:
    print("❌ Tidak dapat menampilkan frame - video tidak dimuat")
    print("Pastikan PATH_VIDEO menuju ke file video yang valid")

    # Tampilkan placeholder
    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
    for row in range(2):
        for i, title in enumerate(["Frame Awal", "Frame Tengah", "Frame Akhir"]):
            axes[row, i].text(0.5, 0.5, f'❌ Video\ntidak dimuat\n\n{title}',
                               transform=axes[row, i].transAxes, fontsize=12,
                               horizontalalignment='center', verticalalignment='center')
            axes[row, i].set_title(f'{title} (No Video)', fontsize=12)
            axes[row, i].axis('off')

    plt.tight_layout()
    plt.show()

📹 Mengekstrak dan menampilkan frame...

✅ Frame berhasil diekstrak!
📊 Resolusi frame: 640 × 360
🎯 Frame yang diekstrak:
   Frame Awal: Frame #0 (waktu 0.00s)
   Frame Tengah: Frame #296 (waktu 9.87s)
   Frame Akhir: Frame #592 (waktu 19.73s)

💡 Total frame berhasil diekstrak: 3
🔄 Video capture resource dibersihkan

Aspek Penilaian	Bobot	Deskripsi
Kelengkapan	35%	Semua langkah inti dikerjakan sesuai checklist
Kualitas Visualisasi	20%	Judul, label sumbu, colorbar, legend, keterbacaan plot
Analisis & Interpretasi	30%	Kemampuan interpretasi hasil, bukan sekadar output mentah
Kerapihan & Struktur	10%	Markdown jelas, kode modular, dokumentasi baik
Orisinalitas & Penguasaan	5%	Pemahaman saat presentasi acak

Tugas Analisis Multimedia: Audio, Gambar, Video¶

Deskripsi Tugas¶

⚠️ CATATAN PENTING: PRESENTASI ACAK & KEJUJURAN AKADEMIK¶

Petunjuk Umum Pengerjaan¶

📋 Cara Menggunakan Template¶

📊 Standar Visualisasi¶

📂 Struktur Data yang Direkomendasikan¶

⚠️ Larangan¶

🎯 Persiapan Presentasi Acak¶

Pendahuluan¶

Apa itu Data Multimedia?¶

Tujuan Tugas¶

Cara Kerja¶

Bagian A — Audio¶

A1. Deskripsi Data¶

A2. TODO: Muat & Metadata¶

A3. TODO: Waveform¶

A4. TODO: Spectrogram log-dB¶

A5. TODO: MFCC¶

A6. Analisis Ringkas (Wajib)¶

Bagian B — Gambar¶

B1. Deskripsi Data¶

B2. TODO: Baca & Tampilkan (RGB)¶

B3. TODO: Informasi Dasar¶

B4. TODO: Histogram Warna¶

B5. Analisis Ringkas (Wajib)¶

Bagian C — Video¶

C1. Deskripsi Data¶

C2. TODO: Baca & Metadata¶

C3. TODO: Tampilkan 3 Frame (Awal–Tengah–Akhir)¶

C4. Analisis Ringkas (Wajib)¶

Perbandingan & Kesimpulan¶

Perbandingan Representasi Media¶

Audio (1D - Temporal)¶

Gambar (2D - Spasial)¶

Video (2D + Waktu - Spatio-temporal)¶

Refleksi Pembelajaran¶

3 Poin yang Saya Pelajari:¶

2 Hal yang Masih Membingungkan/Ingin Diperdalam:¶

Sumber Data & Referensi¶

Rubrik Penilaian¶

Distribusi Bobot Penilaian¶

Detail Kriteria Penilaian¶

🏆 Kelengkapan (35%)¶

📊 Kualitas Visualisasi (20%)¶

🧠 Analisis & Interpretasi (30%)¶

📝 Kerapihan & Struktur (10%)¶

🎯 Orisinalitas & Penguasaan (5%)¶

Proporsi Penilaian Total¶

Aturan Kejujuran Akademik¶

📖 Penggunaan Referensi & AI yang Diperbolehkan¶

⚠️ Syarat & Batasan WAJIB¶

❌ Pelanggaran yang Berakibat Nilai 0¶

🎯 Persiapan Presentasi Acak¶

Panduan Pengumpulan¶

📁 Berkas yang Harus Dikumpulkan¶

Wajib:¶

📅 Informasi Pengumpulan¶

✅ Checklist Sebelum Submit¶

Export ke PDF:¶